import http from '@/util/http'
import router from '@/router'

const state = {
  // 用户信息
  userInfo: {},
  // 是否已登录
  isLoggedIn: false,
  // JWT Token
  token: ''
}

const mutations = {
  // 设置用户信息
  SET_USER: (state, user) => {
    state.userInfo = user
    state.isLoggedIn = true
  },
  // 设置Token
  SET_TOKEN: (state, token) => {
    state.token = token
  },
  // 清除用户信息
  CLEAR_USER: (state) => {
    state.userInfo = {}
    state.isLoggedIn = false
    state.token = ''
  }
}

const actions = {
  // 登录
  login({ commit, dispatch }, userInfo) {
    return new Promise((resolve, reject) => {
      http.post('/user/login', userInfo)
        .then(response => {
          const data = response.data
          if (data.code === 200) {
            const userData = data.data
            
            // 保存用户信息
            commit('SET_USER', userData)
            commit('SET_TOKEN', userData.token)
            
            // 清除现有本地存储，确保没有旧数据
            localStorage.removeItem('isLoggedIn')
            localStorage.removeItem('jwt_token')
            localStorage.removeItem('currentUser')
            localStorage.removeItem('permissionMenus')
            
            // 保存到本地存储
            localStorage.setItem('isLoggedIn', 'true')
            localStorage.setItem('jwt_token', userData.token)
            localStorage.setItem('currentUser', JSON.stringify(userData))
            
            // 确保menus数据存在
            let menus = userData.menus || []
            console.log('从后端获取的原始菜单数据:', menus)
            
            // 如果菜单为空，添加默认统计路由
            if (!Array.isArray(menus) || menus.length === 0) {
              console.warn('后端返回的菜单为空，添加默认菜单')
              menus = [{
                id: 1,
                name: 'statistics',
                path: '/statistics',
                component: 'StatisticsDemo',
                icon: 'el-icon-data-analysis',
                title: '统计图表',
                parentId: 0
              }]
            }
            
            // 规范化菜单路径，确保以/开头
            menus = menus.map(menu => {
              // 复制菜单对象，避免修改原始对象
              const newMenu = { ...menu }
              
              // 确保path以/开头
              if (newMenu.path && !newMenu.path.startsWith('/')) {
                newMenu.path = '/' + newMenu.path
              }
              
              // 如果没有path但有name，创建path
              if (!newMenu.path && newMenu.name) {
                newMenu.path = '/' + newMenu.name
              }
              
              return newMenu
            })
            
            console.log('规范化后的菜单数据:', menus)
            
            // 保存菜单到本地存储
            localStorage.setItem('permissionMenus', JSON.stringify(menus))
            
            // 生成动态路由
            dispatch('permission/generateRoutes', menus, { root: true })
              .then(() => {
                // 登录成功后，跳转到合适的页面
                if (menus && menus.length > 0) {
                  // 确保路径格式正确
                  const firstPath = menus[0].path || '/statistics'
                  console.log('登录成功，跳转到:', firstPath)
                  
                  // 延迟跳转，确保路由已注册
                  setTimeout(() => {
                    router.push(firstPath).catch(err => {
                      console.warn('导航失败，尝试刷新页面:', err)
                      window.location.href = firstPath // 最后的手段：直接修改location
                    })
                  }, 300)
                } else {
                  console.warn('没有可用菜单，跳转到403页面')
                  router.push('/403')
                }
                resolve(userData)
              })
              .catch(err => {
                console.error('生成动态路由失败:', err)
                // 即使路由生成失败，仍然尝试导航到统计页面
                router.push('/statistics').catch(() => {
                  router.push('/login')
                })
                resolve(userData) // 仍然认为登录成功
              })
          } else {
            reject(data.msg || '登录失败')
          }
        })
        .catch(error => {
          console.error('登录请求出错:', error)
          reject(error)
        })
    })
  },
  
  // 退出登录
  logout({ commit, dispatch }) {
    return new Promise(resolve => {
      // 清除用户信息
      commit('CLEAR_USER')
      
      // 清除本地存储
      localStorage.removeItem('isLoggedIn')
      localStorage.removeItem('jwt_token')
      localStorage.removeItem('currentUser')
      localStorage.removeItem('permissionMenus')
      
      // 重置路由
      dispatch('permission/resetRoutes', null, { root: true })
      
      // 跳转到登录页
      router.push('/login')
      
      resolve()
    })
  },
  
  // 从本地存储中恢复用户信息和路由
  restoreUserInfoAndRoutes({ commit, dispatch }) {
    return new Promise(resolve => {
      const token = localStorage.getItem('jwt_token')
      const isLoggedIn = localStorage.getItem('isLoggedIn') === 'true'
      
      if (isLoggedIn && token) {
        console.log('尝试从本地存储恢复用户信息和路由')
        // 恢复用户信息
        const userString = localStorage.getItem('currentUser')
        if (userString) {
          try {
            const userData = JSON.parse(userString)
            commit('SET_USER', userData)
            commit('SET_TOKEN', token)
            
            // 从后端重新获取最新的菜单数据
            http.get('/menu/list/' + userData.role)
              .then(response => {
                const data = response.data
                if (data.code === 200) {
                  // 获取到新的菜单数据
                  const newMenus = data.data || []
                  console.log('从后端重新获取的菜单数据:', newMenus)
                  
                  // 保存到本地存储
                  localStorage.setItem('permissionMenus', JSON.stringify(newMenus))
                  
                  // 生成动态路由
                  dispatch('permission/generateRoutes', newMenus, { root: true })
                    .then(() => {
                      console.log('成功恢复路由状态(使用最新菜单)')
                      resolve(true)
                    })
                    .catch(err => {
                      console.error('生成动态路由失败:', err)
                      // 尝试使用本地存储的菜单作为备份
                      fallbackToLocalMenus()
                    })
                } else {
                  console.warn('获取菜单失败，尝试使用本地缓存:', data.msg)
                  fallbackToLocalMenus()
                }
              })
              .catch(err => {
                console.error('获取菜单请求失败:', err)
                fallbackToLocalMenus()
              })
            
            // 使用本地存储的菜单作为备份的函数
            const fallbackToLocalMenus = () => {
              console.log('尝试使用本地存储的菜单数据作为备份')
              const menuString = localStorage.getItem('permissionMenus')
              if (menuString) {
                try {
                  const menuData = JSON.parse(menuString)
                  console.log('从localStorage恢复的菜单数据:', menuData)
                  
                  // 生成动态路由
                  dispatch('permission/generateRoutes', menuData, { root: true })
                    .then(() => {
                      console.log('成功恢复路由状态(使用缓存菜单)')
                      resolve(true)
                    })
                    .catch(() => {
                      console.error('生成动态路由失败，尝试清除登录状态')
                      dispatch('logout')
                      resolve(false)
                    })
                } catch (e) {
                  console.error('解析菜单数据失败:', e)
                  dispatch('logout')
                  resolve(false)
                }
              } else {
                console.warn('没有找到菜单数据')
                dispatch('logout')
                resolve(false)
              }
            }
          } catch (e) {
            // 解析失败，清除所有状态
            console.error('解析用户数据失败:', e)
            dispatch('logout')
            resolve(false)
          }
        } else {
          console.warn('没有找到用户数据')
          dispatch('logout')
          resolve(false)
        }
      } else {
        console.log('用户未登录或token不存在')
        resolve(false)
      }
    })
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions
} 